/***********************************************************************************************************************
*  OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
*  See also https://openstudio.net/license
***********************************************************************************************************************/

#include "ZoneHVACIdealLoadsAirSystem.hpp"
#include "ZoneHVACIdealLoadsAirSystem_Impl.hpp"

#include "Schedule.hpp"
#include "Schedule_Impl.hpp"
#include "DesignSpecificationOutdoorAir.hpp"
#include "DesignSpecificationOutdoorAir_Impl.hpp"

#include <utilities/idd/IddFactory.hxx>

#include <utilities/idd/OS_ZoneHVAC_IdealLoadsAirSystem_FieldEnums.hxx>
#include <utilities/idd/IddEnums.hxx>

#include "../utilities/core/Assert.hpp"
#include "../utilities/data/DataEnums.hpp"

namespace openstudio {
namespace model {

  namespace detail {

    ZoneHVACIdealLoadsAirSystem_Impl::ZoneHVACIdealLoadsAirSystem_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
      : ZoneHVACComponent_Impl(idfObject, model, keepHandle) {
      OS_ASSERT(idfObject.iddObject().type() == ZoneHVACIdealLoadsAirSystem::iddObjectType());
    }

    ZoneHVACIdealLoadsAirSystem_Impl::ZoneHVACIdealLoadsAirSystem_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model,
                                                                       bool keepHandle)
      : ZoneHVACComponent_Impl(other, model, keepHandle) {
      OS_ASSERT(other.iddObject().type() == ZoneHVACIdealLoadsAirSystem::iddObjectType());
    }

    ZoneHVACIdealLoadsAirSystem_Impl::ZoneHVACIdealLoadsAirSystem_Impl(const ZoneHVACIdealLoadsAirSystem_Impl& other, Model_Impl* model,
                                                                       bool keepHandle)
      : ZoneHVACComponent_Impl(other, model, keepHandle) {}

    const std::vector<std::string>& ZoneHVACIdealLoadsAirSystem_Impl::outputVariableNames() const {
      static const std::vector<std::string> result{"Zone Ideal Loads Supply Air Sensible Heating Energy",
                                                   "Zone Ideal Loads Supply Air Latent Heating Energy",
                                                   "Zone Ideal Loads Supply Air Total Heating Energy",
                                                   "Zone Ideal Loads Supply Air Total Heating Fuel Energy",
                                                   "Zone Ideal Loads Supply Air Sensible Cooling Energy",
                                                   "Zone Ideal Loads Supply Air Latent Cooling Energy",
                                                   "Zone Ideal Loads Supply Air Total Cooling Energy",
                                                   "Zone Ideal Loads Supply Air Total Cooling Fuel Energy",
                                                   "Zone Ideal Loads Zone Sensible Heating Energy",
                                                   "Zone Ideal Loads Zone Latent Heating Energy",
                                                   "Zone Ideal Loads Zone Total Heating Energy",
                                                   "Zone Ideal Loads Zone Heating Fuel Energy",
                                                   "Zone Ideal Loads Zone Sensible Cooling Energy",
                                                   "Zone Ideal Loads Zone Latent Cooling Energy",
                                                   "Zone Ideal Loads Zone Total Cooling Energy",
                                                   "Zone Ideal Loads Zone Cooling Fuel Energy",
                                                   "Zone Ideal Loads Outdoor Air Sensible Heating Energy",
                                                   "Zone Ideal Loads Outdoor Air Latent Heating Energy",
                                                   "Zone Ideal Loads Outdoor Air Total Heating Energy",
                                                   "Zone Ideal Loads Outdoor Air Sensible Cooling Energy",
                                                   "Zone Ideal Loads Outdoor Air Latent Cooling Energy",
                                                   "Zone Ideal Loads Outdoor Air Total Cooling Energy",
                                                   "Zone Ideal Loads Heat Recovery Sensible Heating Energy",
                                                   "Zone Ideal Loads Heat Recovery Latent Heating Energy",
                                                   "Zone Ideal Loads Heat Recovery Total Heating Energy",
                                                   "Zone Ideal Loads Heat Recovery Sensible Cooling Energy",
                                                   "Zone Ideal Loads Heat Recovery Latent Cooling Energy",
                                                   "Zone Ideal Loads Heat Recovery Total Cooling Energy",
                                                   "Zone Ideal Loads Supply Air Sensible Heating Rate",
                                                   "Zone Ideal Loads Supply Air Latent Heating Rate",
                                                   "Zone Ideal Loads Supply Air Total Heating Rate",
                                                   "Zone Ideal Loads Supply Air Total Heating Fuel Energy Rate",
                                                   "Zone Ideal Loads Supply Air Sensible Cooling Rate",
                                                   "Zone Ideal Loads Supply Air Latent Cooling Rate",
                                                   "Zone Ideal Loads Supply Air Total Cooling Rate",
                                                   "Zone Ideal Loads Supply Air Total Cooling Fuel Energy Rate",
                                                   "Zone Ideal Loads Zone Sensible Heating Rate",
                                                   "Zone Ideal Loads Zone Latent Heating Rate",
                                                   "Zone Ideal Loads Zone Total Heating Rate",
                                                   "Zone Ideal Loads Zone Heating Fuel Energy Rate",
                                                   "Zone Ideal Loads Zone Sensible Cooling Rate",
                                                   "Zone Ideal Loads Zone Latent Cooling Rate",
                                                   "Zone Ideal Loads Zone Total Cooling Rate",
                                                   "Zone Ideal Loads Zone Cooling Fuel Energy Rate",
                                                   "Zone Ideal Loads Outdoor Air Sensible Heating Rate",
                                                   "Zone Ideal Loads Outdoor Air Latent Heating Rate",
                                                   "Zone Ideal Loads Outdoor Air Total Heating Rate",
                                                   "Zone Ideal Loads Outdoor Air Sensible Cooling Rate",
                                                   "Zone Ideal Loads Outdoor Air Latent Cooling Rate",
                                                   "Zone Ideal Loads Outdoor Air Total Cooling Rate",
                                                   "Zone Ideal Loads Heat Recovery Sensible Heating Rate",
                                                   "Zone Ideal Loads Heat Recovery Latent Heating Rate",
                                                   "Zone Ideal Loads Heat Recovery Total Heating Rate",
                                                   "Zone Ideal Loads Heat Recovery Sensible Cooling Rate",
                                                   "Zone Ideal Loads Heat Recovery Latent Cooling Rate",
                                                   "Zone Ideal Loads Heat Recovery Total Cooling Rate",
                                                   "Zone Ideal Loads Economizer Active Time",
                                                   "Zone Ideal Loads Heat Recovery Active Time",
                                                   "Zone Ideal Loads Hybrid Ventilation Available Status",
                                                   "Zone Ideal Loads Outdoor Air Mass Flow Rate",
                                                   "Zone Ideal Loads Outdoor Air Standard Density Volume Flow Rate",
                                                   "Zone Ideal Loads Supply Air Mass Flow Rate",
                                                   "Zone Ideal Loads Supply Air Standard Density Volume Flow Rate"};
      return result;
    }

    IddObjectType ZoneHVACIdealLoadsAirSystem_Impl::iddObjectType() const {
      return ZoneHVACIdealLoadsAirSystem::iddObjectType();
    }

    std::vector<ScheduleTypeKey> ZoneHVACIdealLoadsAirSystem_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
      std::vector<ScheduleTypeKey> result;
      UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
      UnsignedVector::const_iterator b(fieldIndices.begin());
      UnsignedVector::const_iterator e(fieldIndices.end());
      if (std::find(b, e, OS_ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName) != e) {
        result.push_back(ScheduleTypeKey("ZoneHVACIdealLoadsAirSystem", "Availability"));
      }
      if (std::find(b, e, OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName) != e) {
        result.push_back(ScheduleTypeKey("ZoneHVACIdealLoadsAirSystem", "Heating Availability"));
      }
      if (std::find(b, e, OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingAvailabilityScheduleName) != e) {
        result.push_back(ScheduleTypeKey("ZoneHVACIdealLoadsAirSystem", "Cooling Availability"));
      }
      if (std::find(b, e, OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingFuelEfficiencyScheduleName) != e) {
        result.push_back(ScheduleTypeKey("ZoneHVACIdealLoadsAirSystem", "Heating Fuel Efficiency"));
      }
      if (std::find(b, e, OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingFuelEfficiencyScheduleName) != e) {
        result.push_back(ScheduleTypeKey("ZoneHVACIdealLoadsAirSystem", "Cooling Fuel Efficiency"));
      }
      return result;
    }

    unsigned ZoneHVACIdealLoadsAirSystem_Impl::inletPort() const {
      return OS_ZoneHVAC_IdealLoadsAirSystemFields::ZoneSupplyAirNodeName;
    }

    unsigned ZoneHVACIdealLoadsAirSystem_Impl::outletPort() const {
      return OS_ZoneHVAC_IdealLoadsAirSystemFields::ZoneExhaustAirNodeName;
    }

    boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem_Impl::availabilitySchedule() const {
      return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName);
    }

    double ZoneHVACIdealLoadsAirSystem_Impl::maximumHeatingSupplyAirTemperature() const {
      boost::optional<double> value = getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirTemperature, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isMaximumHeatingSupplyAirTemperatureDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirTemperature);
    }

    double ZoneHVACIdealLoadsAirSystem_Impl::minimumCoolingSupplyAirTemperature() const {
      boost::optional<double> value = getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirTemperature, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isMinimumCoolingSupplyAirTemperatureDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirTemperature);
    }

    double ZoneHVACIdealLoadsAirSystem_Impl::maximumHeatingSupplyAirHumidityRatio() const {
      boost::optional<double> value = getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirHumidityRatio, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isMaximumHeatingSupplyAirHumidityRatioDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirHumidityRatio);
    }

    double ZoneHVACIdealLoadsAirSystem_Impl::minimumCoolingSupplyAirHumidityRatio() const {
      boost::optional<double> value = getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirHumidityRatio, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isMinimumCoolingSupplyAirHumidityRatioDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirHumidityRatio);
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::heatingLimit() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingLimit, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isHeatingLimitDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingLimit);
    }

    boost::optional<double> ZoneHVACIdealLoadsAirSystem_Impl::maximumHeatingAirFlowRate() const {
      return getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate, true);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isMaximumHeatingAirFlowRateAutosized() const {
      bool result = false;
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate, true);
      if (value) {
        result = openstudio::istringEqual(value.get(), "autosize");
      }
      return result;
    }

    boost::optional<double> ZoneHVACIdealLoadsAirSystem_Impl::maximumSensibleHeatingCapacity() const {
      return getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity, true);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isMaximumSensibleHeatingCapacityAutosized() const {
      bool result = false;
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity, true);
      if (value) {
        result = openstudio::istringEqual(value.get(), "autosize");
      }
      return result;
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::coolingLimit() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingLimit, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isCoolingLimitDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingLimit);
    }

    boost::optional<double> ZoneHVACIdealLoadsAirSystem_Impl::maximumCoolingAirFlowRate() const {
      return getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate, true);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isMaximumCoolingAirFlowRateAutosized() const {
      bool result = false;
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate, true);
      if (value) {
        result = openstudio::istringEqual(value.get(), "autosize");
      }
      return result;
    }

    boost::optional<double> ZoneHVACIdealLoadsAirSystem_Impl::maximumTotalCoolingCapacity() const {
      return getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity, true);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isMaximumTotalCoolingCapacityAutosized() const {
      bool result = false;
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity, true);
      if (value) {
        result = openstudio::istringEqual(value.get(), "autosize");
      }
      return result;
    }

    boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem_Impl::heatingAvailabilitySchedule() const {
      return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName);
    }

    boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem_Impl::coolingAvailabilitySchedule() const {
      return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingAvailabilityScheduleName);
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::dehumidificationControlType() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::DehumidificationControlType, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isDehumidificationControlTypeDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::DehumidificationControlType);
    }

    double ZoneHVACIdealLoadsAirSystem_Impl::coolingSensibleHeatRatio() const {
      boost::optional<double> value = getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingSensibleHeatRatio, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isCoolingSensibleHeatRatioDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingSensibleHeatRatio);
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::humidificationControlType() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HumidificationControlType, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isHumidificationControlTypeDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::HumidificationControlType);
    }

    boost::optional<DesignSpecificationOutdoorAir> ZoneHVACIdealLoadsAirSystem_Impl::designSpecificationOutdoorAirObject() const {
      return getObject<ModelObject>().getModelObjectTarget<DesignSpecificationOutdoorAir>(
        OS_ZoneHVAC_IdealLoadsAirSystemFields::DesignSpecificationOutdoorAirObjectName);
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::demandControlledVentilationType() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::DemandControlledVentilationType, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isDemandControlledVentilationTypeDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::DemandControlledVentilationType);
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::outdoorAirEconomizerType() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::OutdoorAirEconomizerType, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isOutdoorAirEconomizerTypeDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::OutdoorAirEconomizerType);
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::heatRecoveryType() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatRecoveryType, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isHeatRecoveryTypeDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatRecoveryType);
    }

    double ZoneHVACIdealLoadsAirSystem_Impl::sensibleHeatRecoveryEffectiveness() const {
      boost::optional<double> value = getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::SensibleHeatRecoveryEffectiveness, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isSensibleHeatRecoveryEffectivenessDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::SensibleHeatRecoveryEffectiveness);
    }

    double ZoneHVACIdealLoadsAirSystem_Impl::latentHeatRecoveryEffectiveness() const {
      boost::optional<double> value = getDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::LatentHeatRecoveryEffectiveness, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::isLatentHeatRecoveryEffectivenessDefaulted() const {
      return isEmpty(OS_ZoneHVAC_IdealLoadsAirSystemFields::LatentHeatRecoveryEffectiveness);
    }

    boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem_Impl::heatingFuelEfficiencySchedule() const {
      return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingFuelEfficiencyScheduleName);
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::heatingFuelType() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingFuelType, true);
      OS_ASSERT(value);
      return value.get();
    }

    boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem_Impl::coolingFuelEfficiencySchedule() const {
      return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingFuelEfficiencyScheduleName);
    }

    std::string ZoneHVACIdealLoadsAirSystem_Impl::coolingFuelType() const {
      boost::optional<std::string> value = getString(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingFuelType, true);
      OS_ASSERT(value);
      return value.get();
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setAvailabilitySchedule(Schedule& availabilitySchedule) {
      bool result = setSchedule(OS_ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName, "ZoneHVACIdealLoadsAirSystem", "Availability",
                                availabilitySchedule);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetAvailabilitySchedule() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::AvailabilityScheduleName, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setMaximumHeatingSupplyAirTemperature(double maximumHeatingSupplyAirTemperature) {
      bool result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirTemperature, maximumHeatingSupplyAirTemperature);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetMaximumHeatingSupplyAirTemperature() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirTemperature, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setMinimumCoolingSupplyAirTemperature(double minimumCoolingSupplyAirTemperature) {
      bool result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirTemperature, minimumCoolingSupplyAirTemperature);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetMinimumCoolingSupplyAirTemperature() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirTemperature, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setMaximumHeatingSupplyAirHumidityRatio(double maximumHeatingSupplyAirHumidityRatio) {
      bool result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirHumidityRatio, maximumHeatingSupplyAirHumidityRatio);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetMaximumHeatingSupplyAirHumidityRatio() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingSupplyAirHumidityRatio, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setMinimumCoolingSupplyAirHumidityRatio(double minimumCoolingSupplyAirHumidityRatio) {
      bool result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirHumidityRatio, minimumCoolingSupplyAirHumidityRatio);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetMinimumCoolingSupplyAirHumidityRatio() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MinimumCoolingSupplyAirHumidityRatio, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setHeatingLimit(const std::string& heatingLimit) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingLimit, heatingLimit);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetHeatingLimit() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingLimit, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setMaximumHeatingAirFlowRate(boost::optional<double> maximumHeatingAirFlowRate) {
      bool result = false;
      if (maximumHeatingAirFlowRate) {
        result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate, maximumHeatingAirFlowRate.get());
      } else {
        result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate, "");
      }
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetMaximumHeatingAirFlowRate() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate, "");
      OS_ASSERT(result);
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::autosizeMaximumHeatingAirFlowRate() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumHeatingAirFlowRate, "autosize");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setMaximumSensibleHeatingCapacity(boost::optional<double> maximumSensibleHeatingCapacity) {
      bool result = false;
      if (maximumSensibleHeatingCapacity) {
        result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity, maximumSensibleHeatingCapacity.get());
      } else {
        result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity, "");
      }
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetMaximumSensibleHeatingCapacity() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity, "");
      OS_ASSERT(result);
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::autosizeMaximumSensibleHeatingCapacity() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumSensibleHeatingCapacity, "autosize");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setCoolingLimit(const std::string& coolingLimit) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingLimit, coolingLimit);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetCoolingLimit() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingLimit, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setMaximumCoolingAirFlowRate(boost::optional<double> maximumCoolingAirFlowRate) {
      bool result = false;
      if (maximumCoolingAirFlowRate) {
        result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate, maximumCoolingAirFlowRate.get());
      } else {
        result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate, "");
      }
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetMaximumCoolingAirFlowRate() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate, "");
      OS_ASSERT(result);
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::autosizeMaximumCoolingAirFlowRate() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumCoolingAirFlowRate, "autosize");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setMaximumTotalCoolingCapacity(boost::optional<double> maximumTotalCoolingCapacity) {
      bool result = false;
      if (maximumTotalCoolingCapacity) {
        result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity, maximumTotalCoolingCapacity.get());
      } else {
        result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity, "");
      }
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetMaximumTotalCoolingCapacity() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity, "");
      OS_ASSERT(result);
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::autosizeMaximumTotalCoolingCapacity() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::MaximumTotalCoolingCapacity, "autosize");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setHeatingAvailabilitySchedule(Schedule& heatingAvailabilitySchedule) {
      bool result = setSchedule(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName, "ZoneHVACIdealLoadsAirSystem",
                                "Heating Availability", heatingAvailabilitySchedule);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetHeatingAvailabilitySchedule() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingAvailabilityScheduleName, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setCoolingAvailabilitySchedule(Schedule& coolingAvailabilitySchedule) {
      bool result = setSchedule(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingAvailabilityScheduleName, "ZoneHVACIdealLoadsAirSystem",
                                "Cooling Availability", coolingAvailabilitySchedule);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetCoolingAvailabilitySchedule() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingAvailabilityScheduleName, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setDehumidificationControlType(const std::string& dehumidificationControlType) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::DehumidificationControlType, dehumidificationControlType);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetDehumidificationControlType() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::DehumidificationControlType, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setCoolingSensibleHeatRatio(double coolingSensibleHeatRatio) {
      bool result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingSensibleHeatRatio, coolingSensibleHeatRatio);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetCoolingSensibleHeatRatio() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingSensibleHeatRatio, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setHumidificationControlType(const std::string& humidificationControlType) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HumidificationControlType, humidificationControlType);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetHumidificationControlType() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HumidificationControlType, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setDesignSpecificationOutdoorAirObject(
      const boost::optional<DesignSpecificationOutdoorAir>& designSpecificationOutdoorAirObject) {
      bool result = false;
      if (designSpecificationOutdoorAirObject) {
        result = setPointer(OS_ZoneHVAC_IdealLoadsAirSystemFields::DesignSpecificationOutdoorAirObjectName,
                            designSpecificationOutdoorAirObject.get().handle());
      } else {
        result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::DesignSpecificationOutdoorAirObjectName, "");
      }
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetDesignSpecificationOutdoorAirObject() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::DesignSpecificationOutdoorAirObjectName, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setDemandControlledVentilationType(const std::string& demandControlledVentilationType) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::DemandControlledVentilationType, demandControlledVentilationType);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetDemandControlledVentilationType() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::DemandControlledVentilationType, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setOutdoorAirEconomizerType(const std::string& outdoorAirEconomizerType) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::OutdoorAirEconomizerType, outdoorAirEconomizerType);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetOutdoorAirEconomizerType() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::OutdoorAirEconomizerType, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setHeatRecoveryType(const std::string& heatRecoveryType) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatRecoveryType, heatRecoveryType);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetHeatRecoveryType() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatRecoveryType, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setSensibleHeatRecoveryEffectiveness(double sensibleHeatRecoveryEffectiveness) {
      bool result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::SensibleHeatRecoveryEffectiveness, sensibleHeatRecoveryEffectiveness);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetSensibleHeatRecoveryEffectiveness() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::SensibleHeatRecoveryEffectiveness, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setLatentHeatRecoveryEffectiveness(double latentHeatRecoveryEffectiveness) {
      bool result = setDouble(OS_ZoneHVAC_IdealLoadsAirSystemFields::LatentHeatRecoveryEffectiveness, latentHeatRecoveryEffectiveness);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetLatentHeatRecoveryEffectiveness() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::LatentHeatRecoveryEffectiveness, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setHeatingFuelEfficiencySchedule(Schedule& heatingFuelEfficiencySchedule) {
      bool result = setSchedule(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingFuelEfficiencyScheduleName, "ZoneHVACIdealLoadsAirSystem",
                                "Heating Fuel Efficiency", heatingFuelEfficiencySchedule);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetHeatingFuelEfficiencySchedule() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingFuelEfficiencyScheduleName, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setHeatingFuelType(const std::string& heatingFuelType) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingFuelType, heatingFuelType);
      return result;
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setCoolingFuelEfficiencySchedule(Schedule& coolingFuelEfficiencySchedule) {
      bool result = setSchedule(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingFuelEfficiencyScheduleName, "ZoneHVACIdealLoadsAirSystem",
                                "Cooling Fuel Efficiency", coolingFuelEfficiencySchedule);
      return result;
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::resetCoolingFuelEfficiencySchedule() {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingFuelEfficiencyScheduleName, "");
      OS_ASSERT(result);
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setCoolingFuelType(const std::string& coolingFuelType) {
      bool result = setString(OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingFuelType, coolingFuelType);
      return result;
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::heatingLimitValues() const {
      return ZoneHVACIdealLoadsAirSystem::heatingLimitValues();
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::coolingLimitValues() const {
      return ZoneHVACIdealLoadsAirSystem::coolingLimitValues();
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::dehumidificationControlTypeValues() const {
      return ZoneHVACIdealLoadsAirSystem::dehumidificationControlTypeValues();
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::humidificationControlTypeValues() const {
      return ZoneHVACIdealLoadsAirSystem::humidificationControlTypeValues();
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::demandControlledVentilationTypeValues() const {
      return ZoneHVACIdealLoadsAirSystem::demandControlledVentilationTypeValues();
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::outdoorAirEconomizerTypeValues() const {
      return ZoneHVACIdealLoadsAirSystem::outdoorAirEconomizerTypeValues();
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::heatRecoveryTypeValues() const {
      return ZoneHVACIdealLoadsAirSystem::heatRecoveryTypeValues();
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::heatingFuelTypeValues() const {
      return ZoneHVACIdealLoadsAirSystem::heatingFuelTypeValues();
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::coolingFuelTypeValues() const {
      return ZoneHVACIdealLoadsAirSystem::coolingFuelTypeValues();
    }

    boost::optional<ModelObject> ZoneHVACIdealLoadsAirSystem_Impl::availabilityScheduleAsModelObject() const {
      OptionalModelObject result;
      OptionalSchedule intermediate = availabilitySchedule();
      if (intermediate) {
        result = *intermediate;
      }
      return result;
    }

    boost::optional<ModelObject> ZoneHVACIdealLoadsAirSystem_Impl::heatingAvailabilityScheduleAsModelObject() const {
      OptionalModelObject result;
      OptionalSchedule intermediate = heatingAvailabilitySchedule();
      if (intermediate) {
        result = *intermediate;
      }
      return result;
    }

    boost::optional<ModelObject> ZoneHVACIdealLoadsAirSystem_Impl::coolingAvailabilityScheduleAsModelObject() const {
      OptionalModelObject result;
      OptionalSchedule intermediate = coolingAvailabilitySchedule();
      if (intermediate) {
        result = *intermediate;
      }
      return result;
    }

    boost::optional<ModelObject> ZoneHVACIdealLoadsAirSystem_Impl::designSpecificationOutdoorAirObjectAsModelObject() const {
      OptionalModelObject result;
      OptionalDesignSpecificationOutdoorAir intermediate = designSpecificationOutdoorAirObject();
      if (intermediate) {
        result = *intermediate;
      }
      return result;
    }

    boost::optional<ModelObject> ZoneHVACIdealLoadsAirSystem_Impl::heatingFuelEfficiencyScheduleAsModelObject() const {
      OptionalModelObject result;
      OptionalSchedule intermediate = heatingFuelEfficiencySchedule();
      if (intermediate) {
        result = *intermediate;
      }
      return result;
    }

    boost::optional<ModelObject> ZoneHVACIdealLoadsAirSystem_Impl::coolingFuelEfficiencyScheduleAsModelObject() const {
      OptionalModelObject result;
      OptionalSchedule intermediate = coolingFuelEfficiencySchedule();
      if (intermediate) {
        result = *intermediate;
      }
      return result;
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setAvailabilityScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
      if (modelObject) {
        OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
        if (intermediate) {
          Schedule schedule(*intermediate);
          return setAvailabilitySchedule(schedule);
        } else {
          return false;
        }
      } else {
        resetAvailabilitySchedule();
      }
      return true;
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setHeatingAvailabilityScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
      if (modelObject) {
        OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
        if (intermediate) {
          Schedule schedule(*intermediate);
          return setHeatingAvailabilitySchedule(schedule);
        } else {
          return false;
        }
      } else {
        resetHeatingAvailabilitySchedule();
      }
      return true;
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setCoolingAvailabilityScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
      if (modelObject) {
        OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
        if (intermediate) {
          Schedule schedule(*intermediate);
          return setCoolingAvailabilitySchedule(schedule);
        } else {
          return false;
        }
      } else {
        resetCoolingAvailabilitySchedule();
      }
      return true;
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setDesignSpecificationOutdoorAirObjectAsModelObject(const boost::optional<ModelObject>& modelObject) {
      if (modelObject) {
        OptionalDesignSpecificationOutdoorAir intermediate = modelObject->optionalCast<DesignSpecificationOutdoorAir>();
        if (intermediate) {
          return setDesignSpecificationOutdoorAirObject(*intermediate);
        } else {
          return false;
        }
      } else {
        resetDesignSpecificationOutdoorAirObject();
      }
      return true;
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setHeatingFuelEfficiencyScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
      if (modelObject) {
        OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
        if (intermediate) {
          Schedule schedule(*intermediate);
          return setHeatingFuelEfficiencySchedule(schedule);
        } else {
          return false;
        }
      } else {
        resetHeatingFuelEfficiencySchedule();
      }
      return true;
    }

    bool ZoneHVACIdealLoadsAirSystem_Impl::setCoolingFuelEfficiencyScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
      if (modelObject) {
        OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
        if (intermediate) {
          Schedule schedule(*intermediate);
          return setCoolingFuelEfficiencySchedule(schedule);
        } else {
          return false;
        }
      } else {
        resetCoolingFuelEfficiencySchedule();
      }
      return true;
    }

    boost::optional<double> ZoneHVACIdealLoadsAirSystem_Impl::autosizedMaximumHeatingAirFlowRate() const {
      return getAutosizedValue("Design Size Maximum Heating Air Flow Rate", "m3/s");
    }

    boost::optional<double> ZoneHVACIdealLoadsAirSystem_Impl::autosizedMaximumSensibleHeatingCapacity() const {
      return getAutosizedValue("Design Size Maximum Sensible Heating Capacity", "W");
    }

    boost::optional<double> ZoneHVACIdealLoadsAirSystem_Impl::autosizedMaximumCoolingAirFlowRate() const {
      return getAutosizedValue("Design Size Maximum Cooling Air Flow Rate", "m3/s");
    }

    boost::optional<double> ZoneHVACIdealLoadsAirSystem_Impl::autosizedMaximumTotalCoolingCapacity() const {
      return getAutosizedValue("Design Size Maximum Total Cooling Capacity", "W");
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::autosize() {
      autosizeMaximumHeatingAirFlowRate();
      autosizeMaximumSensibleHeatingCapacity();
      autosizeMaximumCoolingAirFlowRate();
      autosizeMaximumTotalCoolingCapacity();
    }

    void ZoneHVACIdealLoadsAirSystem_Impl::applySizingValues() {
      boost::optional<double> val;
      val = autosizedMaximumHeatingAirFlowRate();
      if (val) {
        setMaximumHeatingAirFlowRate(val.get());
      }

      val = autosizedMaximumSensibleHeatingCapacity();
      if (val) {
        setMaximumSensibleHeatingCapacity(val.get());
      }

      val = autosizedMaximumCoolingAirFlowRate();
      if (val) {
        setMaximumCoolingAirFlowRate(val.get());
      }

      val = autosizedMaximumTotalCoolingCapacity();
      if (val) {
        setMaximumTotalCoolingCapacity(val.get());
      }
    }

    std::vector<EMSActuatorNames> ZoneHVACIdealLoadsAirSystem_Impl::emsActuatorNames() const {
      std::vector<EMSActuatorNames> actuators{{"Ideal Loads Air System", "Air Mass Flow Rate"},
                                              {"Ideal Loads Air System", "Outdoor Air Mass Flow Rate"},
                                              {"Ideal Loads Air System", "Air Temperature"},
                                              {"Ideal Loads Air System", "Air Humidity Ratio"}};
      return actuators;
    }

    std::vector<std::string> ZoneHVACIdealLoadsAirSystem_Impl::emsInternalVariableNames() const {
      std::vector<std::string> types;
      return types;
    }

    ComponentType ZoneHVACIdealLoadsAirSystem_Impl::componentType() const {
      return ComponentType::Both;
    }

    std::vector<FuelType> ZoneHVACIdealLoadsAirSystem_Impl::coolingFuelTypes() const {
      return {FuelType::DistrictCooling};
    }

    std::vector<FuelType> ZoneHVACIdealLoadsAirSystem_Impl::heatingFuelTypes() const {
      return {FuelType::DistrictHeating};
    }

    std::vector<AppGFuelType> ZoneHVACIdealLoadsAirSystem_Impl::appGHeatingFuelTypes() const {
      return {AppGFuelType::District};
    }

  }  // namespace detail

  ZoneHVACIdealLoadsAirSystem::ZoneHVACIdealLoadsAirSystem(const Model& model)
    : ZoneHVACComponent(ZoneHVACIdealLoadsAirSystem::iddObjectType(), model) {
    OS_ASSERT(getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>());

    bool ok = true;
    ok = setHeatingFuelType("DistrictHeatingWater");
    OS_ASSERT(ok);
    ok = setCoolingFuelType("DistrictCooling");
    OS_ASSERT(ok);
  }

  IddObjectType ZoneHVACIdealLoadsAirSystem::iddObjectType() {
    return {IddObjectType::OS_ZoneHVAC_IdealLoadsAirSystem};
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::heatingLimitValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingLimit);
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::coolingLimitValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingLimit);
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::dehumidificationControlTypeValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
                          OS_ZoneHVAC_IdealLoadsAirSystemFields::DehumidificationControlType);
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::humidificationControlTypeValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_ZoneHVAC_IdealLoadsAirSystemFields::HumidificationControlType);
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::demandControlledVentilationTypeValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
                          OS_ZoneHVAC_IdealLoadsAirSystemFields::DemandControlledVentilationType);
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::outdoorAirEconomizerTypeValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_ZoneHVAC_IdealLoadsAirSystemFields::OutdoorAirEconomizerType);
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::heatRecoveryTypeValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatRecoveryType);
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::heatingFuelTypeValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_ZoneHVAC_IdealLoadsAirSystemFields::HeatingFuelType);
  }

  std::vector<std::string> ZoneHVACIdealLoadsAirSystem::coolingFuelTypeValues() {
    return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_ZoneHVAC_IdealLoadsAirSystemFields::CoolingFuelType);
  }

  boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem::availabilitySchedule() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->availabilitySchedule();
  }

  double ZoneHVACIdealLoadsAirSystem::maximumHeatingSupplyAirTemperature() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->maximumHeatingSupplyAirTemperature();
  }

  bool ZoneHVACIdealLoadsAirSystem::isMaximumHeatingSupplyAirTemperatureDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isMaximumHeatingSupplyAirTemperatureDefaulted();
  }

  double ZoneHVACIdealLoadsAirSystem::minimumCoolingSupplyAirTemperature() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->minimumCoolingSupplyAirTemperature();
  }

  bool ZoneHVACIdealLoadsAirSystem::isMinimumCoolingSupplyAirTemperatureDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isMinimumCoolingSupplyAirTemperatureDefaulted();
  }

  double ZoneHVACIdealLoadsAirSystem::maximumHeatingSupplyAirHumidityRatio() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->maximumHeatingSupplyAirHumidityRatio();
  }

  bool ZoneHVACIdealLoadsAirSystem::isMaximumHeatingSupplyAirHumidityRatioDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isMaximumHeatingSupplyAirHumidityRatioDefaulted();
  }

  double ZoneHVACIdealLoadsAirSystem::minimumCoolingSupplyAirHumidityRatio() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->minimumCoolingSupplyAirHumidityRatio();
  }

  bool ZoneHVACIdealLoadsAirSystem::isMinimumCoolingSupplyAirHumidityRatioDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isMinimumCoolingSupplyAirHumidityRatioDefaulted();
  }

  std::string ZoneHVACIdealLoadsAirSystem::heatingLimit() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->heatingLimit();
  }

  bool ZoneHVACIdealLoadsAirSystem::isHeatingLimitDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isHeatingLimitDefaulted();
  }

  boost::optional<double> ZoneHVACIdealLoadsAirSystem::maximumHeatingAirFlowRate() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->maximumHeatingAirFlowRate();
  }

  bool ZoneHVACIdealLoadsAirSystem::isMaximumHeatingAirFlowRateAutosized() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isMaximumHeatingAirFlowRateAutosized();
  }

  boost::optional<double> ZoneHVACIdealLoadsAirSystem::maximumSensibleHeatingCapacity() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->maximumSensibleHeatingCapacity();
  }

  bool ZoneHVACIdealLoadsAirSystem::isMaximumSensibleHeatingCapacityAutosized() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isMaximumSensibleHeatingCapacityAutosized();
  }

  std::string ZoneHVACIdealLoadsAirSystem::coolingLimit() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->coolingLimit();
  }

  bool ZoneHVACIdealLoadsAirSystem::isCoolingLimitDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isCoolingLimitDefaulted();
  }

  boost::optional<double> ZoneHVACIdealLoadsAirSystem::maximumCoolingAirFlowRate() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->maximumCoolingAirFlowRate();
  }

  bool ZoneHVACIdealLoadsAirSystem::isMaximumCoolingAirFlowRateAutosized() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isMaximumCoolingAirFlowRateAutosized();
  }

  boost::optional<double> ZoneHVACIdealLoadsAirSystem::maximumTotalCoolingCapacity() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->maximumTotalCoolingCapacity();
  }

  bool ZoneHVACIdealLoadsAirSystem::isMaximumTotalCoolingCapacityAutosized() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isMaximumTotalCoolingCapacityAutosized();
  }

  boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem::heatingAvailabilitySchedule() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->heatingAvailabilitySchedule();
  }

  boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem::coolingAvailabilitySchedule() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->coolingAvailabilitySchedule();
  }

  std::string ZoneHVACIdealLoadsAirSystem::dehumidificationControlType() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->dehumidificationControlType();
  }

  bool ZoneHVACIdealLoadsAirSystem::isDehumidificationControlTypeDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isDehumidificationControlTypeDefaulted();
  }

  double ZoneHVACIdealLoadsAirSystem::coolingSensibleHeatRatio() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->coolingSensibleHeatRatio();
  }

  bool ZoneHVACIdealLoadsAirSystem::isCoolingSensibleHeatRatioDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isCoolingSensibleHeatRatioDefaulted();
  }

  std::string ZoneHVACIdealLoadsAirSystem::humidificationControlType() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->humidificationControlType();
  }

  bool ZoneHVACIdealLoadsAirSystem::isHumidificationControlTypeDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isHumidificationControlTypeDefaulted();
  }

  boost::optional<DesignSpecificationOutdoorAir> ZoneHVACIdealLoadsAirSystem::designSpecificationOutdoorAirObject() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->designSpecificationOutdoorAirObject();
  }

  std::string ZoneHVACIdealLoadsAirSystem::demandControlledVentilationType() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->demandControlledVentilationType();
  }

  bool ZoneHVACIdealLoadsAirSystem::isDemandControlledVentilationTypeDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isDemandControlledVentilationTypeDefaulted();
  }

  std::string ZoneHVACIdealLoadsAirSystem::outdoorAirEconomizerType() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->outdoorAirEconomizerType();
  }

  bool ZoneHVACIdealLoadsAirSystem::isOutdoorAirEconomizerTypeDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isOutdoorAirEconomizerTypeDefaulted();
  }

  std::string ZoneHVACIdealLoadsAirSystem::heatRecoveryType() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->heatRecoveryType();
  }

  bool ZoneHVACIdealLoadsAirSystem::isHeatRecoveryTypeDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isHeatRecoveryTypeDefaulted();
  }

  double ZoneHVACIdealLoadsAirSystem::sensibleHeatRecoveryEffectiveness() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->sensibleHeatRecoveryEffectiveness();
  }

  bool ZoneHVACIdealLoadsAirSystem::isSensibleHeatRecoveryEffectivenessDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isSensibleHeatRecoveryEffectivenessDefaulted();
  }

  double ZoneHVACIdealLoadsAirSystem::latentHeatRecoveryEffectiveness() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->latentHeatRecoveryEffectiveness();
  }

  bool ZoneHVACIdealLoadsAirSystem::isLatentHeatRecoveryEffectivenessDefaulted() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->isLatentHeatRecoveryEffectivenessDefaulted();
  }

  boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem::heatingFuelEfficiencySchedule() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->heatingFuelEfficiencySchedule();
  }

  std::string ZoneHVACIdealLoadsAirSystem::heatingFuelType() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->heatingFuelType();
  }

  boost::optional<Schedule> ZoneHVACIdealLoadsAirSystem::coolingFuelEfficiencySchedule() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->coolingFuelEfficiencySchedule();
  }

  std::string ZoneHVACIdealLoadsAirSystem::coolingFuelType() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->coolingFuelType();
  }

  bool ZoneHVACIdealLoadsAirSystem::setAvailabilitySchedule(Schedule& availabilitySchedule) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setAvailabilitySchedule(availabilitySchedule);
  }

  void ZoneHVACIdealLoadsAirSystem::resetAvailabilitySchedule() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetAvailabilitySchedule();
  }

  bool ZoneHVACIdealLoadsAirSystem::setMaximumHeatingSupplyAirTemperature(double maximumHeatingSupplyAirTemperature) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setMaximumHeatingSupplyAirTemperature(maximumHeatingSupplyAirTemperature);
  }

  void ZoneHVACIdealLoadsAirSystem::resetMaximumHeatingSupplyAirTemperature() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetMaximumHeatingSupplyAirTemperature();
  }

  bool ZoneHVACIdealLoadsAirSystem::setMinimumCoolingSupplyAirTemperature(double minimumCoolingSupplyAirTemperature) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setMinimumCoolingSupplyAirTemperature(minimumCoolingSupplyAirTemperature);
  }

  void ZoneHVACIdealLoadsAirSystem::resetMinimumCoolingSupplyAirTemperature() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetMinimumCoolingSupplyAirTemperature();
  }

  bool ZoneHVACIdealLoadsAirSystem::setMaximumHeatingSupplyAirHumidityRatio(double maximumHeatingSupplyAirHumidityRatio) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setMaximumHeatingSupplyAirHumidityRatio(maximumHeatingSupplyAirHumidityRatio);
  }

  void ZoneHVACIdealLoadsAirSystem::resetMaximumHeatingSupplyAirHumidityRatio() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetMaximumHeatingSupplyAirHumidityRatio();
  }

  bool ZoneHVACIdealLoadsAirSystem::setMinimumCoolingSupplyAirHumidityRatio(double minimumCoolingSupplyAirHumidityRatio) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setMinimumCoolingSupplyAirHumidityRatio(minimumCoolingSupplyAirHumidityRatio);
  }

  void ZoneHVACIdealLoadsAirSystem::resetMinimumCoolingSupplyAirHumidityRatio() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetMinimumCoolingSupplyAirHumidityRatio();
  }

  bool ZoneHVACIdealLoadsAirSystem::setHeatingLimit(const std::string& heatingLimit) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setHeatingLimit(heatingLimit);
  }

  void ZoneHVACIdealLoadsAirSystem::resetHeatingLimit() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetHeatingLimit();
  }

  bool ZoneHVACIdealLoadsAirSystem::setMaximumHeatingAirFlowRate(double maximumHeatingAirFlowRate) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setMaximumHeatingAirFlowRate(maximumHeatingAirFlowRate);
  }

  void ZoneHVACIdealLoadsAirSystem::resetMaximumHeatingAirFlowRate() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetMaximumHeatingAirFlowRate();
  }

  void ZoneHVACIdealLoadsAirSystem::autosizeMaximumHeatingAirFlowRate() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->autosizeMaximumHeatingAirFlowRate();
  }

  bool ZoneHVACIdealLoadsAirSystem::setMaximumSensibleHeatingCapacity(double maximumSensibleHeatingCapacity) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setMaximumSensibleHeatingCapacity(maximumSensibleHeatingCapacity);
  }

  void ZoneHVACIdealLoadsAirSystem::resetMaximumSensibleHeatingCapacity() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetMaximumSensibleHeatingCapacity();
  }

  void ZoneHVACIdealLoadsAirSystem::autosizeMaximumSensibleHeatingCapacity() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->autosizeMaximumSensibleHeatingCapacity();
  }

  bool ZoneHVACIdealLoadsAirSystem::setCoolingLimit(const std::string& coolingLimit) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setCoolingLimit(coolingLimit);
  }

  void ZoneHVACIdealLoadsAirSystem::resetCoolingLimit() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetCoolingLimit();
  }

  bool ZoneHVACIdealLoadsAirSystem::setMaximumCoolingAirFlowRate(double maximumCoolingAirFlowRate) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setMaximumCoolingAirFlowRate(maximumCoolingAirFlowRate);
  }

  void ZoneHVACIdealLoadsAirSystem::resetMaximumCoolingAirFlowRate() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetMaximumCoolingAirFlowRate();
  }

  void ZoneHVACIdealLoadsAirSystem::autosizeMaximumCoolingAirFlowRate() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->autosizeMaximumCoolingAirFlowRate();
  }

  bool ZoneHVACIdealLoadsAirSystem::setMaximumTotalCoolingCapacity(double maximumTotalCoolingCapacity) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setMaximumTotalCoolingCapacity(maximumTotalCoolingCapacity);
  }

  void ZoneHVACIdealLoadsAirSystem::resetMaximumTotalCoolingCapacity() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetMaximumTotalCoolingCapacity();
  }

  void ZoneHVACIdealLoadsAirSystem::autosizeMaximumTotalCoolingCapacity() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->autosizeMaximumTotalCoolingCapacity();
  }

  bool ZoneHVACIdealLoadsAirSystem::setHeatingAvailabilitySchedule(Schedule& heatingAvailabilitySchedule) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setHeatingAvailabilitySchedule(heatingAvailabilitySchedule);
  }

  void ZoneHVACIdealLoadsAirSystem::resetHeatingAvailabilitySchedule() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetHeatingAvailabilitySchedule();
  }

  bool ZoneHVACIdealLoadsAirSystem::setCoolingAvailabilitySchedule(Schedule& coolingAvailabilitySchedule) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setCoolingAvailabilitySchedule(coolingAvailabilitySchedule);
  }

  void ZoneHVACIdealLoadsAirSystem::resetCoolingAvailabilitySchedule() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetCoolingAvailabilitySchedule();
  }

  bool ZoneHVACIdealLoadsAirSystem::setDehumidificationControlType(const std::string& dehumidificationControlType) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setDehumidificationControlType(dehumidificationControlType);
  }

  void ZoneHVACIdealLoadsAirSystem::resetDehumidificationControlType() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetDehumidificationControlType();
  }

  bool ZoneHVACIdealLoadsAirSystem::setCoolingSensibleHeatRatio(double coolingSensibleHeatRatio) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setCoolingSensibleHeatRatio(coolingSensibleHeatRatio);
  }

  void ZoneHVACIdealLoadsAirSystem::resetCoolingSensibleHeatRatio() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetCoolingSensibleHeatRatio();
  }

  bool ZoneHVACIdealLoadsAirSystem::setHumidificationControlType(const std::string& humidificationControlType) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setHumidificationControlType(humidificationControlType);
  }

  void ZoneHVACIdealLoadsAirSystem::resetHumidificationControlType() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetHumidificationControlType();
  }

  bool ZoneHVACIdealLoadsAirSystem::setDesignSpecificationOutdoorAirObject(const DesignSpecificationOutdoorAir& designSpecificationOutdoorAirObject) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setDesignSpecificationOutdoorAirObject(designSpecificationOutdoorAirObject);
  }

  void ZoneHVACIdealLoadsAirSystem::resetDesignSpecificationOutdoorAirObject() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetDesignSpecificationOutdoorAirObject();
  }

  bool ZoneHVACIdealLoadsAirSystem::setDemandControlledVentilationType(const std::string& demandControlledVentilationType) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setDemandControlledVentilationType(demandControlledVentilationType);
  }

  void ZoneHVACIdealLoadsAirSystem::resetDemandControlledVentilationType() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetDemandControlledVentilationType();
  }

  bool ZoneHVACIdealLoadsAirSystem::setOutdoorAirEconomizerType(const std::string& outdoorAirEconomizerType) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setOutdoorAirEconomizerType(outdoorAirEconomizerType);
  }

  void ZoneHVACIdealLoadsAirSystem::resetOutdoorAirEconomizerType() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetOutdoorAirEconomizerType();
  }

  bool ZoneHVACIdealLoadsAirSystem::setHeatRecoveryType(const std::string& heatRecoveryType) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setHeatRecoveryType(heatRecoveryType);
  }

  void ZoneHVACIdealLoadsAirSystem::resetHeatRecoveryType() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetHeatRecoveryType();
  }

  bool ZoneHVACIdealLoadsAirSystem::setSensibleHeatRecoveryEffectiveness(double sensibleHeatRecoveryEffectiveness) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setSensibleHeatRecoveryEffectiveness(sensibleHeatRecoveryEffectiveness);
  }

  void ZoneHVACIdealLoadsAirSystem::resetSensibleHeatRecoveryEffectiveness() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetSensibleHeatRecoveryEffectiveness();
  }

  bool ZoneHVACIdealLoadsAirSystem::setLatentHeatRecoveryEffectiveness(double latentHeatRecoveryEffectiveness) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setLatentHeatRecoveryEffectiveness(latentHeatRecoveryEffectiveness);
  }

  void ZoneHVACIdealLoadsAirSystem::resetLatentHeatRecoveryEffectiveness() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetLatentHeatRecoveryEffectiveness();
  }

  bool ZoneHVACIdealLoadsAirSystem::setHeatingFuelEfficiencySchedule(Schedule& heatingFuelEfficiencySchedule) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setHeatingFuelEfficiencySchedule(heatingFuelEfficiencySchedule);
  }

  void ZoneHVACIdealLoadsAirSystem::resetHeatingFuelEfficiencySchedule() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetHeatingFuelEfficiencySchedule();
  }

  bool ZoneHVACIdealLoadsAirSystem::setHeatingFuelType(const std::string& heatingFuelType) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setHeatingFuelType(heatingFuelType);
  }

  bool ZoneHVACIdealLoadsAirSystem::setCoolingFuelEfficiencySchedule(Schedule& coolingFuelEfficiencySchedule) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setCoolingFuelEfficiencySchedule(coolingFuelEfficiencySchedule);
  }

  void ZoneHVACIdealLoadsAirSystem::resetCoolingFuelEfficiencySchedule() {
    getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->resetCoolingFuelEfficiencySchedule();
  }

  bool ZoneHVACIdealLoadsAirSystem::setCoolingFuelType(const std::string& coolingFuelType) {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->setCoolingFuelType(coolingFuelType);
  }

  /// @cond
  ZoneHVACIdealLoadsAirSystem::ZoneHVACIdealLoadsAirSystem(std::shared_ptr<detail::ZoneHVACIdealLoadsAirSystem_Impl> impl)
    : ZoneHVACComponent(std::move(impl)) {}
  /// @endcond

  boost::optional<double> ZoneHVACIdealLoadsAirSystem::autosizedMaximumHeatingAirFlowRate() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->autosizedMaximumHeatingAirFlowRate();
  }

  boost::optional<double> ZoneHVACIdealLoadsAirSystem::autosizedMaximumSensibleHeatingCapacity() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->autosizedMaximumSensibleHeatingCapacity();
  }

  boost::optional<double> ZoneHVACIdealLoadsAirSystem::autosizedMaximumCoolingAirFlowRate() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->autosizedMaximumCoolingAirFlowRate();
  }

  boost::optional<double> ZoneHVACIdealLoadsAirSystem::autosizedMaximumTotalCoolingCapacity() const {
    return getImpl<detail::ZoneHVACIdealLoadsAirSystem_Impl>()->autosizedMaximumTotalCoolingCapacity();
  }

}  // namespace model
}  // namespace openstudio
